struct Solution bissection(float A, float B, float TOL, int N, float Pol[4])
{
 	int i = 1;

 	float FA = Px(A, Pol);
 	float FB = Px(B, Pol);

 	float FP;
 	float p;

 	float local_A = A;
 	float local_B = B;

   	struct Solution result;

	

 	while(i++ <= N) {


		  p  = local_A+(local_B-local_A)/2;
		  FP = Px(p, Pol);

  			if(((FP<0)?-1*FP:FP) < TOL) {
   				result.SolValide = 1; //indicate that the value returned is valid
				result.Solution = p;
				result.N = i;
				result.Error = (FP*FA<=0)?2*(local_A - 
p):2*(local_B-p);
   				return result;
  		}


 	 	//Set up next iteration
  		if((FA*FP) > 0){
   			local_A = p;
   			FA = FP;
  		} else {
   			local_B = p;
   			FB = FP;
  		}
	}

		result.SolValide = 0;
		return result;
 }









----------------------------------------------------------
char** CreateFrame(char rules[9], int rows, int columns){

	char** Grid = (char**)calloc(rows, sizeof(char*));

	for(int i=0; i<rows;i++){
   		Grid[i] = (char*)calloc(columns, sizeof(char));
   	}


   for(int i=0; i<rows; i++){

   	Grid[i][columns - 1]= '\0';

    	for(int j=0; j<columns -1; j++){

      			if(!i)
               		Grid[i][j] = (j == ((columns-2)/2))?FULL:EMPTY;\

               else{
           	     int index;
                     index = (j==0 || Grid[i-1][j-1]==EMPTY)?0:4;
	             index += (Grid[i-1][j]==EMPTY)?0:2;
                     index += (j == columns - 2||Grid[i-1][j+1]==EMPTY)?0:1;

                     Grid[i][j] = (rules[index]=='1')?FULL:EMPTY;
               }
      }
   }
   return Grid;
}